/**
 * 智慧粮仓 - 其他监控模块
 * 负责显示和管理照明回路、移动风机等状态
 */

// 更新间隔从全局配置中获取
const UPDATE_INTERVAL = getUpdateInterval('OTHER');

// 模块类型和设备类型ID
const MODULE_TYPE_ID = 4; // OTHER模块类型ID
const DEVICE_TYPE_ID = 1; // SIEMENS_S7设备类型ID
const DEVICE_ID = 1;      // 设备ID

// 保存最近获取的数据
let lastDeviceData = {};
let updateTimer = null;
// 标记是否是首次加载
let isFirstLoad = true;

/**
 * 页面加载完成后初始化
 */
$(document).ready(function () {
    console.log("其他监控页面初始化");

    // 初始化公共头部
    initCommonHeader('其他信息');

    // 初始化页面
    init();
});

/**
 * 初始化页面
 */
function init() {
    // 添加触摸反馈效果
    addTouchFeedback();

    // 第一次加载数据
    loadDeviceData();

    // 开始自动更新
    startAutoUpdate();
}

/**
 * 添加触摸反馈效果
 */
function addTouchFeedback() {
    // 为所有可点击元素添加触摸反馈
    const clickableElements = document.querySelectorAll('.control-button, .monitoring-card');

    clickableElements.forEach(element => {
        element.addEventListener('touchstart', function () {
            this.style.opacity = '0.7';
        });

        element.addEventListener('touchend', function () {
            this.style.opacity = '1';
        });

        element.addEventListener('touchcancel', function () {
            this.style.opacity = '1';
        });
    });
}

/**
 * 绑定按钮事件
 */
function bindButtonEvents() {
    // 照明回路全开按钮
    $('#lighting-all-on').off('click').on('click', function () {
        // 获取所有照明回路地址
        const lightingAddresses = [];
        $('.lighting-card .switch-status').each(function () {
            lightingAddresses.push($(this).data('address'));
        });

        // 控制所有照明回路
        lightingAddresses.forEach(address => {
            controlDevice(address, 1);
        });

        showToast('所有照明回路已开启', 'success');
    });

    // 照明回路全关按钮
    $('#lighting-all-off').off('click').on('click', function () {
        // 获取所有照明回路地址
        const lightingAddresses = [];
        $('.lighting-card .switch-status').each(function () {
            lightingAddresses.push($(this).data('address'));
        });

        // 控制所有照明回路
        lightingAddresses.forEach(address => {
            controlDevice(address, 0);
        });

        showToast('所有照明回路已关闭', 'info');
    });

    // 为每个开关状态添加点击事件，实现单个设备控制
    $('.switch-status').off('click').on('click', function () {
        const address = $(this).data('address');
        const currentStatus = $(this).find('.status-dot').hasClass('status-on') ? 1 : 0;
        // 切换状态
        const newStatus = currentStatus === 1 ? 0 : 1;
        controlDevice(address, newStatus);
    });

    // 添加触摸反馈效果
    addTouchFeedback();
}

/**
 * 从服务端加载设备数据
 * @param {boolean} isUpdate 是否为更新操作（非首次加载）
 */
function loadDeviceData(isUpdate = false) {
    console.log("开始加载设备数据...", isUpdate ? "更新操作" : "首次加载");

    if (shouldUseMockData()) {
        console.log("使用模拟数据");
        const mockData = getMockOtherData();

        if (isUpdate) {
            // 更新操作：无感刷新，只更新必要的数据
            updateDeviceDataSilently(mockData);
        } else {
            // 首次加载：完整处理
            lastDeviceData = mockData;
            processDeviceData(mockData);
        }
        return;
    }

    // 调用Android接口获取数据
    try {
        // 准备请求参数
        const params = {
            moduleTypeId: MODULE_TYPE_ID,
            deviceId: DEVICE_ID
        };

        // 使用callAndroidMethodAsync调用Android接口
        callAndroidMethodAsync('getOtherData', params)
            .then(response => {
                console.log("Android接口返回:", response);

                if (response && response.data) {
                    console.log("加载设备数据成功", response.data);
                    // 保存最新数据
                    lastDeviceData = response.data;

                    if (isUpdate) {
                        // 更新操作：无感刷新，只更新必要的数据
                        updateDeviceDataSilently(response.data);
                    } else {
                        // 首次加载：完整处理
                        processDeviceData(response.data);
                    }
                } else {
                    console.error("设备数据格式不正确", response);
                    showToast("设备数据格式不正确", 'error');
                }
            })
            .catch(error => {
                console.error("调用设备数据接口出错", error);
                showToast("设备数据加载失败", 'error');
            });
    } catch (error) {
        console.error("调用设备数据接口出错", error);
        showToast("设备数据加载失败", 'error');
    }
}

/**
 * 处理设备数据，创建或更新卡片
 * @param {Array} deviceData 设备数据数组
 */
function processDeviceData(deviceData) {
    console.log("处理设备数据", deviceData);

    // 检查数据是否存在
    if (!deviceData || deviceData.length === 0) {
        console.log("没有设备数据");
        return;
    }

    // 确保数据是数组格式
    const dataArray = Array.isArray(deviceData) ? deviceData : [deviceData];

    // 清空容器
    const container = $('#device-cards-container');
    container.empty();

    // 按设备类型分组数据
    const pressurePoints = dataArray.filter(p => p.pointType === "VALUE" && p.name.includes("压力"));
    const lightingPoints = dataArray.filter(p => p.pointType === "STATUS" && p.name.includes("照明回路"));
    const mobileFanPoints = dataArray.filter(p => p.name.includes("移动风机插座"));

    console.log("压力测点:", pressurePoints);
    console.log("照明回路测点:", lightingPoints);
    console.log("移动风机测点:", mobileFanPoints);

    // 创建压力卡片
    if (pressurePoints.length > 0) {
        createPressureCard(container, pressurePoints[0]);
    } else {
        // 如果没有压力测点数据，创建一个默认卡片
        createDefaultPressureCard(container);
    }

    // 创建照明回路卡片
    if (lightingPoints.length > 0) {
        createLightingCard(container, lightingPoints);
    }

    // 创建移动风机卡片
    if (mobileFanPoints.length > 0) {
        createFanCard(container, mobileFanPoints);
    }

    // 绑定按钮事件
    bindButtonEvents();

    // 只有首次加载时添加动画效果
    if (isFirstLoad) {
        addCardAnimations();
        isFirstLoad = false; // 设置为非首次加载
    }
}

/**
 * 创建压力卡片
 * @param {Object} container 容器jQuery对象
 * @param {Object} pressurePoint 压力测点数据
 */
function createPressureCard(container, pressurePoint) {
    // 创建压力卡片
    const card = $(`
        <div class="monitoring-card pressure-card">
            <div class="card-header">
                <div class="card-title">${pressurePoint.name || '仓内压力'}</div>
                <div class="status-indicator">
                    <div class="status-dot status-normal"></div>
                    <div class="status-text">正常</div>
                </div>
            </div>
            <div class="card-content">
                <div class="pressure-value">
                    <span class="pressure-number">${Math.round(pressurePoint.value)}</span>
                    <span class="pressure-unit">${pressurePoint.unit || 'KG'}</span>
                </div>
            </div>
        </div>
    `);

    // 添加到容器
    container.append(card);

    // 更新状态
    updatePressureStatus(card, pressurePoint.value);
}

/**
 * 创建默认压力卡片
 * @param {Object} container 容器jQuery对象
 */
function createDefaultPressureCard(container) {
    container.append(`
        <div class="monitoring-card pressure-card">
            <div class="card-header">
                <div class="card-title">仓内压力</div>
                <div class="status-indicator">
                    <div class="status-dot status-normal"></div>
                    <div class="status-text">正常</div>
                </div>
            </div>
            <div class="card-content">
                <div class="pressure-value">
                    <span class="pressure-number">0</span>
                    <span class="pressure-unit">Pa</span>
                </div>
            </div>
        </div>
    `);
}

/**
 * 创建照明回路卡片
 * @param {Object} container 容器jQuery对象
 * @param {Array} lightingPoints 照明回路测点数据
 */
function createLightingCard(container, lightingPoints) {
    const lightingCard = $(`
        <div class="monitoring-card lighting-card">
            <div class="card-header">
                <div class="card-title">照明回路</div>
            </div>
            <div class="card-content">
                <!-- 照明回路状态将在这里动态添加 -->
            </div>
            <div class="control-buttons">
                <button class="control-button" id="lighting-all-on">全开</button>
                <button class="control-button" id="lighting-all-off">全关</button>
            </div>
        </div>
    `);

    // 添加照明回路状态
    const cardContent = lightingCard.find('.card-content');
    lightingPoints.forEach(point => {
        cardContent.append(`
            <div class="switch-status" data-address="${point.address}">
                <div class="switch-label">${point.name}</div>
                <div class="status-indicator">
                    <div class="status-dot ${point.value === 1 ? 'status-on' : 'status-off'}"></div>
                    <div class="status-text">${point.value === 1 ? '开启' : '关闭'}</div>
                </div>
            </div>
        `);
    });

    // 添加到容器
    container.append(lightingCard);
}

/**
 * 创建移动风机卡片
 * @param {Object} container 容器jQuery对象
 * @param {Array} fanPoints 移动风机测点数据
 */
function createFanCard(container, fanPoints) {
    // 获取主测点地址
    const mainPoint = fanPoints[0];
    const controlAddress = mainPoint.address;

    const fanCard = $(`
        <div class="monitoring-card fan-card" data-address="${controlAddress}">
            <div class="card-header">
                <div class="card-title">移动风机插座</div>
            </div>
            <div class="card-content">
                <!-- 移动风机状态将在这里动态添加 -->
            </div>
        </div>
    `);

    // 添加移动风机状态
    const cardContent = fanCard.find('.card-content');
    
    // 添加运行状态和故障报警作为开关状态项
    if (mainPoint.attributes && mainPoint.attributes.length > 0) {
        // 查找运行状态属性
        const runStatusAttr = mainPoint.attributes.find(attr => attr.pointType === 'RUN_STATUS');
        if (runStatusAttr) {
            cardContent.append(`
                <div class="switch-status" data-address="${runStatusAttr.address}">
                    <div class="switch-label">${runStatusAttr.name}</div>
                    <div class="status-indicator">
                        <div class="status-dot ${runStatusAttr.value === 1 ? 'status-on' : 'status-off'}"></div>
                        <div class="status-text">${runStatusAttr.value === 1 ? '开启' : '关闭'}</div>
                    </div>
                </div>
            `);
        }

        // 查找故障报警属性
        const faultAttr = mainPoint.attributes.find(attr => attr.pointType === 'FAULT_ALARM');
        if (faultAttr) {
            cardContent.append(`
                <div class="switch-status" data-address="${faultAttr.address}">
                    <div class="switch-label">${faultAttr.name}</div>
                    <div class="status-indicator">
                        <div class="status-dot ${faultAttr.value === 1 ? 'status-alarm' : 'status-normal'}"></div>
                        <div class="status-text">${faultAttr.value === 1 ? '故障' : '正常'}</div>
                    </div>
                </div>
            `);
        }
    }

    // 添加到容器
    container.append(fanCard);
}

/**
 * 添加卡片动画效果
 */
function addCardAnimations() {
    $('.monitoring-card').each(function (index) {
        const card = $(this);
        card.css({
            'opacity': '0',
            'transform': 'translateY(10px)'
        });

        setTimeout(() => {
            card.css({
                'transition': 'all 0.4s cubic-bezier(0.25, 0.1, 0.25, 1)',
                'opacity': '1',
                'transform': 'translateY(0)'
            });
        }, 100 + index * 50); // 级联延迟
    });
}

/**
 * 更新压力状态指示器
 * @param {Object} card 压力卡片jQuery对象
 * @param {number} value 压力值
 */
function updatePressureStatus(card, value) {
    const statusDot = card.find('.status-dot');
    const statusText = card.find('.status-text');

    if (value > 1800) {
        statusDot.removeClass().addClass('status-dot status-error');
        statusText.text('危险');
    } else if (value > 1500) {
        statusDot.removeClass().addClass('status-dot status-warning');
        statusText.text('警告');
    } else {
        statusDot.removeClass().addClass('status-dot status-normal');
        statusText.text('正常');
    }
}

/**
 * 更新设备状态
 * @param {string} address 设备地址
 * @param {number} value 设备状态值
 */
function updateDeviceStatus(address, value) {
    const statusElement = $(`.switch-status[data-address="${address}"]`);
    if (statusElement.length > 0) {
        const statusDot = statusElement.find('.status-dot');
        const statusText = statusElement.find('.status-text');

        if (parseInt(value) === 1) {
            statusDot.removeClass().addClass('status-dot status-on');
            // 根据设备类型显示不同的状态文本
            if (address.startsWith('4006') && parseInt(address.slice(-1)) >= 6) {
                statusText.text('运行中');
            } else {
                statusText.text('开启');
            }
        } else {
            statusDot.removeClass().addClass('status-dot status-off');
            if (address.startsWith('4006') && parseInt(address.slice(-1)) >= 6) {
                statusText.text('已停止');
            } else {
                statusText.text('关闭');
            }
        }
    }
}

/**
 * 控制设备状态
 * @param {string} address 设备地址
 * @param {number} value 设备状态值
 */
function controlDevice(address, value) {
    console.log(`控制设备: ${address}, 值: ${value}`);

    if (shouldUseMockData()) {
        console.log("使用模拟控制");
        // 模拟控制，直接更新UI
        updateDeviceStatus(address, value);
        // 更新本地缓存的数据
        if (lastDeviceData && Array.isArray(lastDeviceData)) {
            const point = lastDeviceData.find(p => p.address === address);
            if (point) {
                point.value = value;
            }
        }
        showToast(`设备控制成功`, 'success');
        return;
    }

    // 调用Android接口控制设备
    try {
        // 准备请求参数
        const params = {
            moduleTypeId: MODULE_TYPE_ID,
            deviceTypeId: DEVICE_TYPE_ID,
            deviceId: DEVICE_ID,
            address: address,
            value: value
        };

        console.log("发送控制命令:", params);

        // 使用callAndroidMethodAsync调用Android接口
        callAndroidMethodAsync('controlOtherDevice', params)
            .then(response => {
                console.log("控制设备响应:", response);

                if (response && response.code === 0) {
                    console.log("控制设备成功");

                    // 更新本地缓存的数据
                    if (lastDeviceData && Array.isArray(lastDeviceData)) {
                        const point = lastDeviceData.find(p => p.address === address);
                        if (point) {
                            point.value = value;
                        }
                    }

                    // 重新加载数据，确保UI与实际状态一致
                    setTimeout(() => {
                        loadDeviceData();
                    }, 1000);

                    showToast(`设备控制成功`, 'success');
                } else {
                    console.error("控制设备失败", response ? response.msg : '未知错误');
                    showToast("设备控制失败: " + (response ? response.msg : '未知错误'), 'error');
                }
            })
            .catch(error => {
                console.error("控制设备失败", error);
                showToast("设备控制失败: " + error, 'error');
            });
    } catch (error) {
        console.error("控制设备失败", error);
        showToast("设备控制失败: " + error, 'error');
    }
}

/**
 * 开始自动更新
 */
function startAutoUpdate() {
    // 清除可能存在的旧定时器
    if (updateTimer) {
        clearInterval(updateTimer);
    }

    // 设置新的定时器
    updateTimer = setInterval(() => {
        loadDeviceData(true); // 传递isUpdate=true参数，表示这是更新操作
    }, UPDATE_INTERVAL);

    console.log(`自动更新已启动，间隔: ${UPDATE_INTERVAL}ms`);
}

/**
 * 无感刷新设备数据
 * @param {Array} deviceData 设备数据数组
 */
function updateDeviceDataSilently(deviceData) {
    console.log("无感刷新设备数据", deviceData);

    if (!deviceData || deviceData.length === 0) {
        console.log("没有设备数据");
        return;
    }

    // 确保数据是数组格式
    const dataArray = Array.isArray(deviceData) ? deviceData : [deviceData];

    // 更新压力值,目前是写死根据englishName
    const pressurePoint = dataArray.find(p => p.englishName === "Warehouse_Pressure");
    if (pressurePoint) {
        const pressureCard = $('.pressure-card');
        if (pressureCard.length > 0) {
            pressureCard.find('.pressure-number').text(pressurePoint.value);
            // 动态显示单位
            const unit = pressurePoint.unit || 'KG';
            pressureCard.find('.pressure-unit').text(unit);
            updatePressureStatus(pressureCard, pressurePoint.value);
        }
    }

    // 更新设备状态
    dataArray.filter(p => p.pointType === "STATUS").forEach(point => {
        const statusElement = $(`.switch-status[data-address="${point.address}"]`);
        if (statusElement.length > 0) {
            const statusDot = statusElement.find('.status-dot');
            const statusText = statusElement.find('.status-text');

            if (parseInt(point.value) === 1) {
                statusDot.removeClass().addClass('status-dot status-on');
                // 根据设备类型显示不同的状态文本
                if (point.address.startsWith('4006') && parseInt(point.address.slice(-1)) >= 6) {
                    statusText.text('运行中');
                } else {
                    statusText.text('开启');
                }
            } else {
                statusDot.removeClass().addClass('status-dot status-off');
                if (point.address.startsWith('4006') && parseInt(point.address.slice(-1)) >= 6) {
                    statusText.text('已停止');
                } else {
                    statusText.text('关闭');
                }
            }
        }
    });

    // 如果DOM中没有找到对应的元素，说明DOM结构可能发生了变化，需要重新生成
    if ($('.monitoring-card').length === 0) {
        console.log("DOM结构不存在，重新生成");
        processDeviceData(deviceData);
    }
}

